import matplotlib.pylab as plt
import numpy as np
import tensorflow as tf
from os import listdir
from PIL import Image
from matplotlib.pyplot import figure, imshow, axis
from matplotlib.image import imread
import os
%matplotlib inline
import sys
if (os.getcwd().split("/")[-1]=="evaluation"):
os.chdir("../")
import subprocess
import importlib
import shutil
import gc
import random
from utils import change_active_config, copy_n_rand_patches
from evaluation import read_tensor_from_image_file, load_graph, load_labels
import constants
import time, sys
from IPython.display import clear_output
def update_progress(progress):
bar_length = 20
if isinstance(progress, int):
progress = float(progress)
if not isinstance(progress, float):
progress = 0
if progress < 0:
progress = 0
if progress >= 1:
progress = 1
block = int(round(bar_length * progress))
clear_output(wait = True)
text = "Progreso: [{0}] {1:.1f}%".format( "#" * block + "-" * (bar_length - block), progress * 100)
print(text)
def evaluate_and_show(src_dir, model_file, labels_file, input_height = 299,input_width = 299, show=0):
input_mean = 0
input_std = 255
input_layer = "Placeholder"
output_layer = "final_result"
files = [os.path.join(src_dir, file) for file in listdir(src_dir)]
all_preds = []
graph = load_graph(model_file)
fig = plt.figure(figsize=(20,20))
no_of_files = len(files)
files_to_show = random.sample(files,show)
with tf.Session(graph=graph) as sess:
for i,f in enumerate(files_to_show):
t = read_tensor_from_image_file(
sess,
f,
input_height=input_height,
input_width=input_width,
input_mean=input_mean,
input_std=input_std)
input_name = "import/" + input_layer
output_name = "import/" + output_layer
input_operation = graph.get_operation_by_name(input_name)
output_operation = graph.get_operation_by_name(output_name)
results = sess.run(output_operation.outputs[0], {
input_operation.outputs[0]: t
})
results = np.squeeze(results)
predic = results.argsort()[::-1]
labels = load_labels(labels_file)
subplt=fig.add_subplot(np.sqrt(show), np.sqrt(show) ,i+1)
plt.xticks([])
plt.yticks([])
plt.tight_layout()
color="green" if (labels[predic[0]].startswith("ben") or labels[predic[0]].startswith("neg")) else "red"
subplt.set_xlabel(labels[predic[0]]+" "+str(results[predic[0]]),color=color).set_fontsize(20)
name = f.split("/")[-1]
color="green" if name.startswith("neg") else "red" if name.startswith("pos") else "blue"
subplt.set_title(name,color=color).set_fontsize(22)
image = imread(f)
imshow(image)
return
def get_stats(src_dir, model_file, labels_file, samples_per_class = 200, input_height = 299,input_width = 299):
input_mean = 0
input_std = 255
input_layer = "Placeholder"
output_layer = "final_result"
if (os.path.exists(src_dir + "/tmp_imgs/")):
shutil.rmtree(src_dir + "/tmp_imgs/")
os.mkdir(src_dir+"tmp_imgs/")
copy_n_rand_patches(src_dir+"positive/", src_dir + "tmp_imgs/", samples_per_class)
copy_n_rand_patches(src_dir+"negative/", src_dir + "tmp_imgs/", samples_per_class)
files = [os.path.join(src_dir + "tmp_imgs/", file) for file in listdir(src_dir + "tmp_imgs/")]
graph = load_graph(model_file)
sample = random.sample(files,samples_per_class)
all_predicts = []
all_labels = []
with tf.Session(graph=graph) as sess:
for i,image in enumerate(sample):
tensor = read_tensor_from_image_file(sess,
image,
input_height=input_height,
input_width=input_width,
input_mean=input_mean,
input_std=input_std)
input_name = "import/" + input_layer
output_name = "import/" + output_layer
input_operation = graph.get_operation_by_name(input_name)
output_operation = graph.get_operation_by_name(output_name)
results = sess.run(output_operation.outputs[0], {
input_operation.outputs[0]: tensor
})
results = np.squeeze(results)
predic = results.argsort()[::-1]
labels = load_labels(labels_file)
all_labels.append(1 if "pos" in image else 0)
all_predicts.append(predic[0])
number_of_elements = 1000
update_progress(i / len(sample))
update_progress(1)
shutil.rmtree(src_dir + "/tmp_imgs/")
gc.collect()
return all_labels, all_predicts
def retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps, no_imgs_per_class=5000):
if (os.path.exists(src_dir_train + "/tmp_imgs/")):
shutil.rmtree(src_dir_train + "/tmp_imgs/")
os.mkdir(src_dir_train+"tmp_imgs/")
os.mkdir(src_dir_train+"tmp_imgs/positive/")
os.mkdir(src_dir_train+"tmp_imgs/negative/")
copy_n_rand_patches(src_dir_train+"positive/", src_dir_train + "tmp_imgs/positive/", no_imgs_per_class)
copy_n_rand_patches(src_dir_train+"negative/", src_dir_train + "tmp_imgs/negative/", no_imgs_per_class)
test_accuracy = subprocess.run(["python","evaluation/retrain.py",
"--image_dir={}".format(src_dir_train + "/tmp_imgs/"),
"--how_many_training_steps={}".format(steps),
"--output_graph={}".format(model),
"--output_labels={}".format(labels)]).stdout
evaluate_and_show(src_dir_eval, model, labels, show = 9)
shutil.rmtree(src_dir_train + "/tmp_imgs/")
return test_accuracy
def eval_accuracy(src_dir_test, model, labels, samples_per_class = [500,5000]):
results = []
for n in samples_per_class:
predictions, bin_labels = get_stats(src_dir_test, model, labels, samples_per_class = n)
acc = accuracy(predictions, bin_labels)
results.append("N: " + str(n) + " - " + "Precision: " + str(acc))
print(str(n) + "-" + str(acc))
return results
def accuracy(predictions, bin_labels):
correctas = np.sum(np.asarray(predictions) == np.asarray(bin_labels))
accuracy = correctas / len(predictions)
return accuracy
dataset = "camelyon_17_16_level0"
change_active_config(dataset)
importlib.reload(constants)
#Entrenamiento y evaluacion visual con imagenes reales
src_dir_train= constants.BASE_PATH + constants.DATA_PATH
src_dir_eval= "test_images/histo_l0/evaluation/real/"
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
src_dir_test= constants.BASE_PATH + constants.OUTPUT_PATH
model="evaluation/trained_models/incp_v3_5k_l0_real.pb"
labels="evaluation/labels.txt"
#Reentrenar inception con todo el dataset puede tomar bastante tiempo
#se pueden obtener precisiones similares con un set mucho mas pequeño y
#con la consecuente reducción de tiempo.
test_accuracy = retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 5000)
#Primero vamos a evaluarlo con imagenes reales para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
print(eval_accuracy(src_dir_test, model, labels))
#Entrenamiento imagenes generadas
src_dir_train= constants.BASE_PATH + constants.OUTPUT_PATH
src_dir_eval= "test_images/histo_l0/evaluation/fake/"
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
src_dir_test= constants.BASE_PATH + constants.DATA_PATH
model="evaluation/trained_models/incp_v3_5k_l0_gen.pb"
labels="evaluation/labels.txt"
retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 5000)
#Primero vamos a evaluarlo con imagenes generadas para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
print(eval_accuracy(src_dir_test, model, labels))
#Si encontramos problemas al ejecutar el notebook jupyter de una sola vez
#puede que necesitemos reiniciar el kernel debido a un problema con la liberacion de memoria por parte de la gpu
#Entrenamiento y evaluacion visual con imagenes reales
src_dir_train= constants.BASE_PATH + constants.DATA_PATH
src_dir_eval= "test_images/histo_l0/evaluation/real/"
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
src_dir_test= constants.BASE_PATH + constants.OUTPUT_PATH
model="evaluation/trained_models/incp_v3_15k_l0_real.pb"
labels="evaluation/labels.txt"
#Reentrenar inception con todo el dataset puede tomar bastante tiempo
#se pueden obtener precisiones similares con un set mucho mas pequeño y
#con la consecuente reducción de tiempo.
test_accuracy = retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 15000)
#Primero vamos a evaluarlo con imagenes reales para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
print(eval_accuracy(src_dir_test, model, labels))
#Entrenamiento y evaluacion visual con imagenes generadas
src_dir_train= constants.BASE_PATH + constants.OUTPUT_PATH
src_dir_eval= "test_images/histo_l0/evaluation/fake/"
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
src_dir_test= constants.BASE_PATH + constants.DATA_PATH
model="evaluation/trained_models/incp_v3_15k_l0_gen.pb"
labels="evaluation/labels.txt"
retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 15000)
#Primero vamos a evaluarlo con imagenes generadas para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
print(eval_accuracy(src_dir_test, model, labels))
dataset = "camelyon_17_16_level1"
change_active_config(dataset)
importlib.reload(constants)
#Entrenamiento y evaluacion visual con imagenes reales
src_dir_train= constants.BASE_PATH + constants.DATA_PATH
src_dir_eval= "test_images/histo_l1/evaluation/real/"
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
src_dir_test= constants.BASE_PATH + constants.OUTPUT_PATH
model="evaluation/trained_models/incp_v3_5k_l1_real.pb"
labels="evaluation/labels.txt"
#Reentrenar inception con todo el dataset puede tomar bastante tiempo
#se pueden obtener precisiones similares con un set mucho mas pequeño y
#con la consecuente reducción de tiempo.
test_accuracy = retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 5000)
#Primero vamos a evaluarlo con imagenes reales para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
print(eval_accuracy(src_dir_test, model, labels))
#Entrenamiento imagenes generadas
src_dir_train= constants.BASE_PATH + constants.OUTPUT_PATH
src_dir_eval= "test_images/histo_l1/evaluation/fake/"
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
src_dir_test= constants.BASE_PATH + constants.DATA_PATH
model="evaluation/trained_models/incp_v3_5k_l1_gen.pb"
labels="evaluation/labels.txt"
retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 5000)
#Primero vamos a evaluarlo con imagenes generadas para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
print(eval_accuracy(src_dir_test, model, labels))
#Si encontramos problemas al ejecutar el notebook jupyter de una sola vez
#puede que necesitemos reiniciar el kernel debido a un problema con la liberacion de memoria por parte de la gpu
#Entrenamiento y evaluacion visual con imagenes reales
src_dir_train= constants.BASE_PATH + constants.DATA_PATH
src_dir_eval= "test_images/histo_l1/evaluation/real/"
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
src_dir_test= constants.BASE_PATH + constants.OUTPUT_PATH
model="evaluation/trained_models/incp_v3_15k_l1_real.pb"
labels="evaluation/labels.txt"
#Reentrenar inception con todo el dataset puede tomar bastante tiempo
#se pueden obtener precisiones similares con un set mucho mas pequeño y
#con la consecuente reducción de tiempo.
test_accuracy = retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 15000)
#Primero vamos a evaluarlo con imagenes reales para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes reales y testeamos con imagenes generadas
print(eval_accuracy(src_dir_test, model, labels))
#Entrenamiento y evaluacion visual con imagenes generadas
src_dir_train= constants.BASE_PATH + constants.OUTPUT_PATH
src_dir_eval= "test_images/histo_l1/evaluation/fake/"
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
src_dir_test= constants.BASE_PATH + constants.DATA_PATH
model="evaluation/trained_models/incp_v3_15k_l1_gen.pb"
labels="evaluation/labels.txt"
retrain_and_evaluate(src_dir_train, src_dir_eval, model, labels, steps = 5000, no_imgs_per_class = 15000)
#Primero vamos a evaluarlo con imagenes generadas para tener una referencia
print(eval_accuracy(src_dir_train, model, labels))
#Hemos entrenado con imagenes generadas y testeamos con imagenes reales
print(eval_accuracy(src_dir_test, model, labels))